const Common = require('./common');//引入公共方法
const SignModel = require('../models/sign');//引入admin表的model层
const Constant = require('../constant/constant');//引入常量
const dateFormat = require('dateformat');//引入dateformat包
const Token = require('./token');//引入Token处理方法
const moment = require('moment')//引入moment方法

//配置对象
let exportObj = {
  createSign,
  createKey,
  testSign,
  signIn,
  reSet,
  getSign
};

module.exports = exportObj;

function createSign(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 校验参数方法
    checkParams: (cb) => {
      // 调用公共方法中的校验参数方法，成功继续后面操作，失败则传递错误信息到async最终方法
      cb(null)
    },
    // 添加方法，依赖校验参数方法
    add: cb => {
      // 使用wish的model中的方法插入到数据库
      SignModel
        .create({
          id: req.body.studentNo,
          class: req.body.classNo,
          studentname: req.body.studentName,
          role: 'user',
        })
        .then(function (result) {
          // 插入结果处理
          // 继续后续操作
          cb(null);
        })
        .catch(function (err) {
          // 错误处理
          // 打印错误日志
          console.log(err);
          // 传递错误信息到async最终方法
          cb(Constant.DEFAULT_ERROR);
        });
    },
  }
  //Common.autoFn(tasks, res. resObj)
  Common.autoFn(tasks, res, resObj);
}

function createKey(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 更新方法，依赖校验参数方法
    update: cb => {
      var t1 = moment();
      // 使用admin的model中的方法更新
      SignModel
        .update({
          latitude: req.query.latitude,
          longitude: req.query.longitude,
          sign: 1,
          signKey: 1,
          signTime: t1.toString()
        }, {
          where: {
            id: req.query.studentNo
          }
        })
        .then(function (result) {
          // 更新结果处理
          if (result) {
            // 如果更新成功
            // 继续后续操作
            // 使用admin的model中的方法更新
            resObj.data = {
              signKey: 1
            }
            cb(null);
          } else {
            // 更新失败，传递错误信息到async最终方法
            cb(Constant.ADMIN_NOT_EXSIT);
          }
        })
        .catch(function (err) {
          // 错误处理
          // 打印错误日志
          console.log(err);
          console.log(t1.toString())
          // 传递错误信息到async最终方法
          cb(Constant.DEFAULT_ERROR);
        });
    }
  };
  // 执行公共方法中的autoFn方法，返回数据
  Common.autoFn(tasks, res, resObj)
}

//检验签到条件
function testSign(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 校验参数方法
    checkParams: (cb) => {
      cb(null)
    },
    query: ['checkParams', (results, cb) => {
      SignModel
        .findOne({
          where: {
            class: req.body.classNo,
            role: 'admin'
          }
        })
        .then(function (result) {
          //查询结果处理
          if (result) {
            //如果查询到了结果
            //组装数据，并将查询结果组装到成功返回的数据中
            var t2 = moment()
            console.log(result.signTime)
            if (t2.diff(moment(result.signTime), 'minute') > 5) {
              cb(Constant.TIME_ERROR)
            } else {
              resObj.data = {
                longitude: result.longitude,
                latitude: result.latitude,
                signKey: result.signKey
              };
              cb(null);
            }
          } else {
            //没有查询到结果，传递错误信息到async的最终方法中
            cb(Constant.ADMIN_NOT_EXSIT);
          }
        })
        .catch(function (err) {
          //错误处理
          console.log(err);
          cb(Constant.DEFAULT_ERROR)
        })
    }],
  };
  //Common.autoFn(tasks, res. resObj)
  Common.autoFn(tasks, res, resObj);
}

//签到录入
function signIn(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 更新方法，依赖校验参数方法
    update: cb => {
      // 使用admin的model中的方法更新
      SignModel
        .update({
          sign: 1,
        }, {
          where: {
            id: req.body.studentNo
          }
        })
        .then(function (result) {
          // 更新结果处理
          if (result) {
            // 如果更新成功
            // 继续后续操作
            resObj.data = {
              sign: 1
            }
            cb(null);
          } else {
            // 更新失败，传递错误信息到async最终方法
            cb(Constant.ADMIN_NOT_EXSIT);
          }
        })
        .catch(function (err) {
          // 错误处理
          // 打印错误日志
          console.log(err);
          // 传递错误信息到async最终方法
          cb(Constant.DEFAULT_ERROR);
        });
    }
  };
  // 执行公共方法中的autoFn方法，返回数据
  Common.autoFn(tasks, res, resObj);
}


//重置签到状态
function reSet(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 更新方法，依赖校验参数方法
    update: cb => {
      // 使用admin的model中的方法更新
      SignModel
        .update({
          sign: 0,
          signKey:0,
          signTime:''
        },{
          where:{
           class:req.body.classNo 
          }
        }).then(function (result) {
          // 更新结果处理
          if (result) {
            // 如果更新成功
            // 继续后续操作
            resObj.data = {
              reset: 'OK'
            }
            cb(null);
          } else {
            // 更新失败，传递错误信息到async最终方法
            cb(Constant.ADMIN_NOT_EXSIT);
          }
        })
        .catch(function (err) {
          // 错误处理
          // 打印错误日志
          console.log(err);
          // 传递错误信息到async最终方法
          cb(Constant.DEFAULT_ERROR);
        });
    }
  };
  // 执行公共方法中的autoFn方法，返回数据
  Common.autoFn(tasks, res, resObj);
}

//查询签到情况 
function getSign(req, res) {
  // 定义一个返回对象
  const resObj = Common.clone(Constant.DEFAULT_SUCCESS);
  // 定义一个async任务
  let tasks = {
    // 校验参数方法
    checkParams: (cb) => {
      cb(null)
    },
    query: ['checkParams', (results, cb) => {
      SignModel
        .findAll({
          where: {
            class: req.body.classNo,
            role: 'user',
            sign: 0
          }
        })
        .then(function (result) {
          //查询结果处理
          if (result) {
            //如果查询到了结果
            //组装数据，并将查询结果组装到成功返回的数据中
               // 查询结果处理
          // 定义一个空数组list，用来存放最终结果
          let list = [];
          // 遍历SQL查询出来的结果，处理后装入list
          result.forEach ((v, i) => {
            let obj = {
              studentNo: v.id,
              studentName: v.studentname
            };
            list.push (obj);
          });
          // 给返回结果赋值，包括列表和总条数
          resObj.data = {
            list
          };
              cb(null);      
          } else {
            //没有查询到结果，传递错误信息到async的最终方法中
            cb(Constant.ADMIN_NOT_EXSIT);
          }
        })
        .catch(function (err) {
          //错误处理
          console.log(err);
          console.log(req.query)
          cb(Constant.DEFAULT_ERROR)
        })
    }],
  };
  //Common.autoFn(tasks, res. resObj)
  Common.autoFn(tasks, res, resObj);
}